package com.ygxsk.carhome.ui.usercenter;

import android.content.DialogInterface;
import android.content.pm.ActivityInfo;
import android.graphics.Paint;
import android.os.Build;
import android.os.Bundle;
import android.os.Handler;
import android.os.Message;
import android.text.TextUtils;
import android.util.Log;
import android.view.KeyEvent;
import android.view.View;
import android.view.animation.Animation;
import android.view.animation.AnimationUtils;
import android.widget.CheckBox;
import android.widget.LinearLayout;
import android.widget.TextView;

import androidx.annotation.NonNull;
import androidx.core.content.ContextCompat;

import com.afollestad.materialdialogs.DialogAction;
import com.afollestad.materialdialogs.GravityEnum;
import com.afollestad.materialdialogs.MaterialDialog;
import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.serializer.SerializerFeature;
import com.arialyy.annotations.Download;
import com.arialyy.aria.core.Aria;
import com.arialyy.aria.core.task.DownloadTask;
import com.arialyy.aria.util.ALog;
import com.blankj.utilcode.util.ActivityUtils;
import com.blankj.utilcode.util.AppUtils;
import com.blankj.utilcode.util.EncodeUtils;
import com.blankj.utilcode.util.EncryptUtils;
import com.blankj.utilcode.util.FileUtils;
import com.blankj.utilcode.util.KeyboardUtils;
import com.blankj.utilcode.util.LogUtils;
import com.blankj.utilcode.util.NetworkUtils;
import com.blankj.utilcode.util.ObjectUtils;
import com.blankj.utilcode.util.PathUtils;
import com.blankj.utilcode.util.StringUtils;
import com.blankj.utilcode.util.ToastUtils;
import com.blankj.utilcode.util.Utils;
import com.flyco.roundview.RoundTextView;
import com.gyf.immersionbar.ImmersionBar;
import com.hjq.permissions.OnPermissionCallback;
import com.hjq.permissions.XXPermissions;
import com.hjq.toast.Toaster;
import com.lxj.xpopup.XPopup;
import com.lxj.xpopup.util.XPopupUtils;
import com.tencent.mmkv.MMKV;
import com.trello.rxlifecycle4.android.ActivityEvent;
import com.umeng.commonsdk.UMConfigure;
import com.umeng.message.PushAgent;
import com.yanzhenjie.permission.AndPermission;
import com.yanzhenjie.permission.runtime.Permission;
import com.ygxsk.carhome.CarApplication;
import com.ygxsk.carhome.ICallbackResult;
import com.ygxsk.carhome.R;
import com.ygxsk.carhome.alertview.AlertView;
import com.ygxsk.carhome.alertview.OnItemClickListener;
import com.ygxsk.carhome.constant.ConstantApi;
import com.ygxsk.carhome.constant.ConstantSign;
import com.ygxsk.carhome.constant.ExtraKey;
import com.ygxsk.carhome.constant.ExtraValue;
import com.ygxsk.carhome.greendao.LoginInfoDaoManager;
import com.ygxsk.carhome.helper.PushHelper;
import com.ygxsk.carhome.listener.AuthorityCallbackListener;
import com.ygxsk.carhome.listener.DoubleClickListener;
import com.ygxsk.carhome.listener.MianTaskManager;
import com.ygxsk.carhome.listener.SequenceListener;
import com.ygxsk.carhome.permission.PermissionSetting;
import com.ygxsk.carhome.permission.RuntimeRationale;
import com.ygxsk.carhome.response.CustomerActor;
import com.ygxsk.carhome.response.LoginBean;
import com.ygxsk.carhome.retrofit.AddLogUpLoadInfo;
import com.ygxsk.carhome.retrofit.ApiException;
import com.ygxsk.carhome.retrofit.ApiRequestSubListener;
import com.ygxsk.carhome.retrofit.ApiService;
import com.ygxsk.carhome.retrofit.ErrorConsumer;
import com.ygxsk.carhome.retrofit.NetworkManager;
import com.ygxsk.carhome.retrofit.ResponseTransformer;
import com.ygxsk.carhome.sys.PermissionInterceptor;
import com.ygxsk.carhome.sys.PermissionNameConvert;
import com.ygxsk.carhome.sys.Session;
import com.ygxsk.carhome.ui.ErrorActivity;
import com.ygxsk.carhome.ui.home.HomeMainFragmentActivity;
import com.ygxsk.carhome.utils.CommTools;
import com.ygxsk.carhome.utils.CommUtils;
import com.ygxsk.carhome.views.ClearEditTextUser;
import com.ygxsk.integrated.retrofit.Parameterkey;

import java.io.File;
import java.lang.ref.WeakReference;
import java.nio.charset.Charset;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.concurrent.TimeUnit;

import butterknife.BindView;
import butterknife.OnClick;
import io.reactivex.rxjava3.android.schedulers.AndroidSchedulers;
import io.reactivex.rxjava3.core.Observable;
import io.reactivex.rxjava3.disposables.CompositeDisposable;
import io.reactivex.rxjava3.functions.Consumer;
import okhttp3.MediaType;
import okhttp3.RequestBody;

/*
 * @Author:itchenqi175@163.com
 * @Time:2023-07-22  11:01
 * @Description:汽车员工端真实的登录页面
 */
public class LoginCarActivity extends ErrorActivity {

    @BindView(R.id.etphonenumber)
    ClearEditTextUser etPhoneNumber;

    @BindView(R.id.etpassword)
    ClearEditTextUser etPassWord;

    @BindView(R.id.checkboxagreementinlogin)
    CheckBox checkBoxAgreeMentInLogin;

    //勾选隐私协议的包裹选择框和提示文字
    @BindView(R.id.linearlayouttoptwoconinlogincar)
    LinearLayout linearLayoutTopTwoConInLogin;

    @BindView(R.id.textsecrecyturlinlogin)
    TextView textSecrecytUrlInLogin;

    @BindView(R.id.textagreementurlinlogin)
    TextView textAgreeMentuUrlInLogin;

    @BindView(R.id.btn_login_inlogin)
    RoundTextView btnLoginInLogin;

    @BindView(R.id.textDoorOpenInLogin)
    TextView textDoorOpenInLogin;

    //------------------------------------
    //从哪个界面跳转到登录界面的标识标记
    private int login_index_flag;
    private PushAgent mPushAgent;

    //点击退出的标志
    private boolean isExit = false;

    //提示有更新的弹窗
    private MaterialDialog materialDialogHasUpdateData;
    //添加下载的进度圈
    private MaterialDialog materialDialogDownLoadProgress;
    //该下载apk任务的任务id值内容；
    private long taskDownLoadApkId;

    private final ICallbackResult callbackResult = new ICallbackResult() {

        @Override
        public void OnBackResult(int currentResult) {

            if (currentResult != ConstantApi.APK_DOWNLOADFAIL_FLAG) {

                if (materialDialogDownLoadProgress != null) {

                    try {
                        materialDialogDownLoadProgress.incrementProgress(1);//每次增加量1
                        materialDialogDownLoadProgress.setProgress(currentResult);//设置进度
                    } catch (Exception e) {
//                        if (!ObjectUtils.isEmpty(e)) {
//                            LogUtils.d(ConstantApi.LOGCAT_NOMAL + "更新-登录页-materialDialogProgress-进度-有异常->" + e.getMessage());
//                        }
                        e.printStackTrace();
                    }

                    materialDialogDownLoadProgress.setOnShowListener(new DialogInterface.OnShowListener() {//更新进度
                        @Override
                        public void onShow(DialogInterface dialoginterface) {
                            //更新进度内容
                            final MaterialDialog curdialog = (MaterialDialog) dialoginterface;

                            if (curdialog.getCurrentProgress() != curdialog.getMaxProgress()) {

                                if (!LoginCarActivity.this.isFinishing()) {//如果界面没有被杀死

                                    if (curdialog.isCancelled()) {
                                        return;
                                    }
                                }
                            }
                        }
                    });

                } else {

                    //-----------------------------------------------------------------
                    //弹窗没有弹出，那么也是无法下载的，需要杀掉服务
                    //-----------------------------------------------------------------
                }

            } else {

                try {

                    //do

//                    LogUtils.d("itchen--即将执行-APK_DOWNLOADFAIL_FLAG--解除服务断开，关闭弹窗，杀死服务的工作");

                    //2022-11-15 09:27:09 关闭弹窗，消除掉所有可能有得内存泄露问题
                    if (materialDialogDownLoadProgress != null) {
                        CommUtils.checkMaterialDialog(materialDialogDownLoadProgress);
                    }

                } catch (Exception e) {
                    //catch
//                    if (!ObjectUtils.isEmpty(e)) {
//                        LogUtils.d(ConstantApi.LOGCAT_NOMAL + "下载失败的报错日志=>" + e.getLocalizedMessage());
//                    }
                    e.printStackTrace();
                } finally {
//                    LogUtils.d(ConstantApi.LOGCAT_NOMAL + "必然执行了=>materialDialogProgress再检查关闭一次");
                    if (materialDialogDownLoadProgress != null) {
                        CommUtils.checkMaterialDialog(materialDialogDownLoadProgress);
                    }
                }

            }

        }
    };

    //添加用户隐私协议内容
//    private MaterialDialog materialDialogSecrecytUrl;

    @OnClick({R.id.btn_login_inlogin,//登录
            R.id.textagreementurlinlogin,//用户协议
            R.id.textsecrecyturlinlogin,//隐私政策
            R.id.linearlayouttoptwoconinlogincar//隐私协议的文本
    })//
    public void clickInLoginCarView(View view) {

        switch (view.getId()) {

            //登录界面没有返回按钮，打开就直接是登录界面,这个可能将来会放开再用到
            case R.id.btn_login_inlogin: {

                KeyboardUtils.hideSoftInput(LoginCarActivity.this);

                //这里好像导致点击 有些反应迟钝，我屏蔽了。
                //if (!DoubleClickListener.isFastDoubleClick()) {

                //调用登录接口
                if (NetworkUtils.isConnected()) {

                    //2022年6月13日 如果发现 tonken 没有 需要重新获取token;
                    if (TextUtils.isEmpty(MMKV.defaultMMKV().decodeString(ConstantSign.P_TOKEN, mSession.getToken()))) {
                        CommUtils.getTokenInterface(NetworkManager.getInstance().getPublic_url_prefix(), mActivityInstance, mSession);
                    }

                    //真实的放开
                    gainDatas();

                } else {

                    ToastUtils.showShort(ConstantSign.NONET);
                    //点开是网络设置；
                    CommUtils.setNetwork(LoginCarActivity.this);

                }

                //}

                break;
            }


            //代码不可删掉
            case R.id.textagreementurlinlogin: {//用户协议

                if (!DoubleClickListener.isFastDoubleClick()) {
                    //跳转到一个H5界面即可
                    CommUtils.methodAgreementUrl(mActivityInstance);
                }

                break;
            }

            case R.id.textsecrecyturlinlogin: {//用户隐私政策

                if (!DoubleClickListener.isFastDoubleClick()) {
                    CommUtils.methodSecrecytUrl(mActivityInstance);
                }
                break;
            }

            case R.id.linearlayouttoptwoconinlogincar: {//用户是否同意隐私协议的勾选点击

//                if (!DoubleClickListener.isFastDoubleClick()) {
                if (checkBoxAgreeMentInLogin != null) {
                    //勾选互斥。
                    checkBoxAgreeMentInLogin.setChecked(!checkBoxAgreeMentInLogin.isChecked());
                }
                //软键盘关闭
                if (KeyboardUtils.isSoftInputVisible(LoginCarActivity.this)) {
                    KeyboardUtils.hideSoftInput(LoginCarActivity.this);
                }

//                }

                break;
            }

            default:
                break;
        }

    }

    //退出登录页面的监听标识
    private static final int EXTI_HANDLER = 1002;

    private static class BetterHandlerInLogin extends Handler {

        WeakReference<LoginCarActivity> mActivityInSide;

        public BetterHandlerInLogin(LoginCarActivity loginActivity) {
            this.mActivityInSide = new WeakReference<LoginCarActivity>(loginActivity);
        }

        @Override
        public void handleMessage(@NonNull Message msg) {

            LoginCarActivity currentActivity = mActivityInSide.get();

            if (currentActivity != null) {

                //只有一个事件，就是退出该页面
                switch (msg.what) {

                    case EXTI_HANDLER: {

                        currentActivity.isExit = false;

                        break;
                    }

                    default:
                        break;
                }

            }


        }
    }


    private BetterHandlerInLogin mHandler;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);

        //LogUtils.d("itchen---mActivityInstance->"+mActivityInstance);

        try {
            //设置坚屏 一定要放到try catch里面，否则会崩溃
            setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_PORTRAIT);
        } catch (Exception e) {
            //
        }

        if (mHandler == null) {
            //mHandler = new BetterHandlerInLogin(this, Looper.getMainLooper());
            mHandler = new BetterHandlerInLogin(this);
        }

        mActivityInstance = this;

        mSession = Session.get(LoginCarActivity.this);

        if (mCompositeDisposable == null) {
            mCompositeDisposable = new CompositeDisposable();
        }

        Bundle bundleFrom = this.getIntent().getExtras();

        if (bundleFrom != null) {
            login_index_flag = bundleFrom.getInt(ExtraKey.EXTRA_REQUEST_20401);
            //extra_request_environment = bundleFrom.getInt(ConstantApi.EXTRA_REQUEST_ENVIRONMENT);
        }

        // : 2023-07-22 14:57 腾讯X5要不要再次加载？
//        preInitX5Core();
//        mSetting = new PermissionSetting(this);

        initViews();

        //===================end=======================================================================
        mPushAgent = PushAgent.getInstance(this.getApplicationContext());
        mPushAgent.onAppStart();//??可以不可以反复调用
        //LogUtils.d("itchen---LoginActivity--onCreate");


        //===================start=======================================================================

        LogUtils.d(ConstantSign.LOGCAT_NOMAL + "在登录页验证下是否同意用户隐私政策-->" + (MMKV.defaultMMKV().decodeBool(ConstantSign.P_SECRECYTURL_AGREE)));

        //如果点击了同意，那么再次注册，能到登录页，其实已经是【同意】过得。
        if ((MMKV.defaultMMKV().decodeBool(ConstantSign.P_SECRECYTURL_AGREE))) {

            UMConfigure.submitPolicyGrantResult(LoginCarActivity.this, true);
            PushHelper.init(LoginCarActivity.this);

//            mPushAgent.register(new IUmengRegisterCallback() {
//
//                @Override
//                public void onSuccess(String deviceToken) {
//
//                    //注册成功会返回deviceToken deviceToken是推送消息的唯一标志
//                    //注册成功会返回device token
//                    //MMKV.defaultMMKV().encode("deviceToken", deviceToken);
//                    MMKV.defaultMMKV().encode(ConstantSign.UMENG_PUSHAGENT_REGISTER_DEVICETOKEN, deviceToken);
//
//                    //2019年04月27日发现覆盖安装token不变，但是卸载掉重新安装会有问题
//                    LogUtils.d("itchen--LoginCarActivity类--mPushAgent---注册成功--deviceToken-->" + deviceToken);
//                    //AgV4v_rAlZ37cFD6S_sankbvRbI-pg1h46JjDLttmKxg
//                    //itchen----mPushAgent---注册成功--deviceToken-->AvGgkdVYLgjuH6e1gElN7bCfT2frOiGaTpmGZrLLxGQ8
//                    //itchen----mPushAgent---注册成功--deviceToken-->AibIfOA6do7PDx3Nf2BLV_QOuUb6-dMc8uLq_ItI-h47
//
//                    //2021年10月23日16:42:12 的日志内容。
//                    //itchen----mPushAgent---注册成功--deviceToken-->AhZrzebqx2BtZSI9fic-LLNJ3EO_osHq0yBlNqY5R-GH
//
//                }
//
//                @Override
//                public void onFailure(String errCode, String errDesc) {
//
//                    //Log.e(TAG, "register failure：--> " + "code:" + errCode + ",desc:" + errDesc);
////                LogUtils.d("itchen---->register failure：--> " + "code:" + errCode + ",desc:" + errDesc);
//                    LogUtils.d("itchen--LoginCarActivity类--itchen_deviceToken---注册失败--fail-->" + errCode + "-->" + errDesc);
//                    //itchen--itchen_deviceToken---注册失败--fail-->-11-->accs bindapp error!
//
//                }
//
//            });

        }

        //===================end=======================================================================

        //注册一个下载
        Aria.download(this).register();

        //点击屏幕空白区域隐藏软键盘
        //KeyboardUtils.clickBlankArea2HideSoftInput();
        //首次安装不更新APP,因为市场审核不通过， 非首次可以执行更新APP的弹窗
//        if (!MMKV.defaultMMKV().decodeBool(ConstantSign.MMKV_IS_FIRST_INSTALL_CONTROL_UPDATE_APK_DIALOG)) {
//            methodUpdateVersion();
//        } else {
//            LogUtils.d(ConstantSign.LOGCAT_NOMAL + "用户是首次安装APP，不能弹出更新apk弹窗");
//        }

        //如果是【首次登录】那么就不提示升级
        if (MMKV.defaultMMKV().decodeBool(ConstantSign.MMKV_IS_FIRST_INSTALL_CONTROL_UPDATE_APK_DIALOG)) {
//            LogUtils.d(ConstantSign.LOGCAT_NOMAL + "-用户是首次登录-，不检查版本更新");
        } else {

            methodUpdateVersion();

//            mCompositeDisposable.add(Observable.timer(ConstantApi.TIME_DELAY2000, TimeUnit.MILLISECONDS)
//                    .subscribeOn(AndroidSchedulers.mainThread())//
//                    .observeOn(AndroidSchedulers.mainThread())//
//                    .compose(LoginCarActivity.this.bindUntilEvent(ActivityEvent.DESTROY))//
//                    .subscribe(new Consumer<Long>() {
//                        @Override
//                        public void accept(Long aLong) throws Exception {
//                            methodUpdateVersion();
//                        }
//                    }));

        }

        //发起一个一秒钟的检测token信息，如果不存在，那末，添加重新获取token
        mCompositeDisposable.add(Observable.timer(ConstantApi.GETTOKENINTERFACE_TIME_DELAY, TimeUnit.MILLISECONDS)
                .subscribeOn(AndroidSchedulers.mainThread())//
                .observeOn(AndroidSchedulers.mainThread())//
                .compose(LoginCarActivity.this.bindUntilEvent(ActivityEvent.DESTROY))//最好做个管理生命周期，因为这个接口调用次数多
                .subscribe(new Consumer<Long>() {
                    @Override
                    public void accept(Long aLong) throws Exception {

                        if (MMKV.defaultMMKV().decodeBool(ConstantSign.P_SECRECYTURL_AGREE)) {

                            if (TextUtils.isEmpty(MMKV.defaultMMKV().decodeString(ConstantSign.P_TOKEN))) {

//                                LogUtils.d("itchen----GETTOKENINTERFACE_TIME_DELAY--->发现本地的token 是空值---重新获取");
                                //添加处理未读消息的接口
                                CommUtils.getTokenInterface(NetworkManager.getInstance().getPublic_url_prefix(), LoginCarActivity.this, mSession);

                            }

                        } else {
                            Log.d(ConstantSign.LOGCAT_NOMAL, "登录页面，用户还【未同意】隐私政策~不能调用接口");
                        }
                    }
                }));


    }

    @Override
    protected void initImmersionBar() {
        super.initImmersionBar();

        // TODO: 2023-07-04 11:01 设置状态栏；
        //ImmersionBar.with(this).titleBar(toolbar).init();

        ImmersionBar.with(this)//
                .titleBar(R.id.toolbarygxskout)
                .fitsSystemWindows(true)//解决状态栏和布局重叠问题，任选其一，默认为false，当为true时一定要指定statusBarColor()，不然状态栏为透明色，还有一些重载方法
                //.statusBarColor(R.color.colorPrimary)//
                //.navigationBarColor(R.color.colorPrimary)//
                //.keyboardEnable(true)
                .init();


    }


    @Override
    protected int getContentViewId() {
        return R.layout.activity_login_car;
    }

    /**
     * 初始化X5内核，这个在打开每个web的时候只有一次回调。
     */
//    private void preInitX5Core() {
//
//        try {
//            //do
//            Intent intent = new Intent(LoginCarActivity.this, X5CorePreLoadService.class);
//            startService(intent);
//
//        } catch (Exception e) {
//            //catch
//            e.printStackTrace();
//        }
//
//    }
    @Override
    protected void initToolBar(ToolbarHelper toolbarHelper) {

        //这个是没有的

    }

    @Override
    protected void onClickNodata(View v) {

        //retain

    }

    @Override
    protected void initViews() {

        //本地记录的处理
        //登录界面记住上次登录的手机号的问题
        if (!TextUtils.isEmpty(mSession.getInputNameLastTime())) {//记住 上次输入的用户名
            //LogUtils.d("itchen----->记住上次的用户输入是==>" + mSession.getInputNameLastTime());
            etPhoneNumber.setText(mSession.getInputNameLastTime());
        } else {
            //retain什么都不填写
        }

        //初始化处理：低版本的checkbox的处理
        if (checkBoxAgreeMentInLogin != null) {
            checkBoxAgreeMentInLogin.setButtonDrawable(null);
        }

        //隐私政策和用户协议的下划线
        if (textSecrecytUrlInLogin != null) {
            textSecrecytUrlInLogin.getPaint().setFlags(Paint.UNDERLINE_TEXT_FLAG);//下划线
            textSecrecytUrlInLogin.getPaint().setAntiAlias(true);//抗锯齿
        }

        if (textAgreeMentuUrlInLogin != null) {
            textAgreeMentuUrlInLogin.getPaint().setFlags(Paint.UNDERLINE_TEXT_FLAG);//下划线
            textAgreeMentuUrlInLogin.getPaint().setAntiAlias(true);//抗锯齿
        }

        if (textDoorOpenInLogin != null) {
            textDoorOpenInLogin.setOnLongClickListener(new View.OnLongClickListener() {
                @Override
                public boolean onLongClick(View v) {

                    CommUtils.method_open(mSession, mActivityInstance);

                    return true;
                }
            });
        }
    }

    @Override
    protected void gainDatas() {

        //这里需要对手机号和验证码做校验。
        String yourName = etPhoneNumber.getText().toString().trim();
        //不论登录成功或者失败 都要保存该用户输入的那个名称
        String yourPassword = etPassWord.getText().toString().trim();
//        LogUtils.d("itchen---->密码信息---->" + yourPassword);
        String driviceTokenLocal = mPushAgent.getRegistrationId();
        LogUtils.d("itchen---->友盟消息推送的---->" + driviceTokenLocal);

        //首先验证是不包含特殊符号的字符串
        //再验证是否是邮箱
        //---是否是正确的邮箱
        //再验证是否是正常的手机号
        //---在验证手机号格式是否正确。
        //------------------------------------------------------------
        //如果是个邮箱就放过
        /*if (!TextUtils.isEmpty(youreName)){

            if (RegexUtils.isEmail(youreName)){
                LogUtils.d("itchen--->是个邮箱--逻辑往下走");
            }

            if (RegexUtils.isMobileSimple(youreName)){

                LogUtils.d("itchen--->是个手机号---那就验证是否是精准手机号");

                if (!RegexUtils.isMobileExact(youreName)) {//精确验证手机号
                    method_showAlert("请输入有效手机号");
                    return;
                }

            }else{
                method_showAlert("电话格式不对");
                return;
            }

        }else{

            method_showAlert("请输入用户名/邮箱/手机号");
            //如果是空 就拦截。
            return;
        }*/


        //用户名手机端不用做限制，因为用户名是后台生成的：后台生成啥，
        // 必须让手机端能随意输入。不能做限制，万一后台生产的带有特殊符号呢。
        //所以只需要在提交登录接口时候，验证用户名或者密码正确或者错误就可以了。
        if (TextUtils.isEmpty(yourName)) {
            method_showAlert(getString(R.string.login_input_username));
            return;
        }

        //2020-6-17 16:50:24 对上次用户输入的那个名字做保存
        if (mSession != null) {
            mSession.setInputNameLastTime(yourName);
        }

        //------------------------------------------------------------
        if (TextUtils.isEmpty(yourPassword)) {
            method_showAlert(getString(R.string.login_input_password));
            return;
        }

        //---------------------------------------------------------------------------
        //2021-7-19 09:37:09 添加勾选隐私协议的拦截
        if (!checkBoxAgreeMentInLogin.isChecked()) {

            //第一种方式
            //method_showAlert("请勾选下方隐私协议");

            //第二种方式 2022年6月23日 我修改为振动的方式；
            //CommUtils.displayToastShortCenter("请勾选下方隐私协议");

            //直接使用垂直弹窗
            new XPopup.Builder(mActivityInstance)
//                        .isCenterHorizontal(true)
                    .isDestroyOnDismiss(true) //对于只使用一次的弹窗，推荐设置这个
                    .atView(LoginCarActivity.this.findViewById(R.id.checkboxagreementinlogin))//在勾选复选框的上方添加弹出
                    .hasShadowBg(false) // 去掉半透明背景
//                        .offsetX(XPopupUtils.dp2px(getContext(), 20))
                    .offsetY(XPopupUtils.dp2px(mActivityInstance, 6))
                    .asCustom(new CustomBubbleAttachPopup(mActivityInstance)
//                                .setArrowOffset(-XPopupUtils.dp2px(getContext(), 40))  //气泡箭头偏移
//                                .setBubbleBgColor(Color.RED)  //气泡背景
                                    .setArrowWidth(XPopupUtils.dp2px(mActivityInstance, 5))
                                    .setArrowHeight(XPopupUtils.dp2px(mActivityInstance, 6))
//                                .setBubbleRadius(100)
                                    .setArrowRadius(XPopupUtils.dp2px(mActivityInstance, 3))
                    )
                    .show();


            //使用该界面做勾选的振动；
            if (linearLayoutTopTwoConInLogin != null) {
                Animation animationTwoCon = AnimationUtils.loadAnimation(mActivityInstance, R.anim.translate_checkbox_shake);
                linearLayoutTopTwoConInLogin.startAnimation(animationTwoCon);
            }

            return;
        }

        //---------------------------------------------------------------------------
        HashMap<String, Object> map = new HashMap<>();
        map.put(Parameterkey.inputBox, yourName);
        map.put(Parameterkey.password, EncodeUtils.base64Encode2String((EncryptUtils.encryptMD5ToString(yourPassword)).getBytes(Charset.defaultCharset())));
        map.put(Parameterkey.deviceToken, driviceTokenLocal);

        AddLogUpLoadInfo addLogUpLoadInfo = new AddLogUpLoadInfo();
        addLogUpLoadInfo.setActivity(mActivityInstance);
        addLogUpLoadInfo.setWhat(ConstantApi.WHAT_APPLOGIN);//请求数字标识
        addLogUpLoadInfo.setUrlPath(ApiService.appLoginUrl);//url地址
        addLogUpLoadInfo.setRequestMethod(ConstantSign.REQUEST_METHOD_POST);//POST 或者 GET
        addLogUpLoadInfo.setToastToUser(true);//展示给用户的标志
        addLogUpLoadInfo.setHashMapParameter(map);

        //做界面展示给用户的
        NetworkManager.getInstance().initRetrofitRxJava()
                .create(ApiService.class)
                .appLogin(RequestBody.create(JSON.toJSONString(map, SerializerFeature.PrettyFormat, SerializerFeature.WriteMapNullValue), MediaType.parse(ApiService.HEADER_JSON)))
//                .doOnSubscribe(new Consumer<Disposable>() {
//                    @Override
//                    public void accept(Disposable disposable) throws Exception {
//                        //在提交数据之前有一些操作
//                        //可以添加不同个性化的弹窗等
//                        LogUtils.d("itchen--->登录的请求开始了，可以显示个dialog。---> onStart");
//                        //这里要检查 是否有token没有的话先请求token
                //个人信息这个是一直新增的，不删除的；
//                    }
//                }).subscribeOn(AndroidSchedulers.mainThread())
                .compose(LoginCarActivity.this.bindUntilEvent(ActivityEvent.DESTROY))//
                .compose(new ResponseTransformer<>(addLogUpLoadInfo, //
                        new ApiRequestSubListener<LoginBean>(ConstantApi.IS_ACTIVITY_ITSELF, LoginCarActivity.this) {//

                            @Override
                            public void handlerSomeThingNotSuccessDataForItSelf(int what_method, String serverCode, String serverMessage) {
                                super.handlerSomeThingNotSuccessDataForItSelf(what_method, serverCode, serverMessage);

                                CommTools.errorTokenOrEqument(mActivityInstance, serverCode, serverMessage, mSession, new SequenceListener() {

                                    @Override
                                    public void doSomeThing() {

                                        if (!TextUtils.isEmpty(serverMessage)) {
                                            ToastUtils.showShort(serverCode + StringUtils.getString(R.string.logintokeerrorcode) + serverMessage);
                                        } else {
                                            ToastUtils.showShort(StringUtils.getString(R.string.logintokenorequmentnull) + serverCode);
                                        }
                                    }

                                });
                            }

                        }))
                .subscribe(new Consumer<LoginBean>() {
                    @Override
                    public void accept(LoginBean loginBean) throws Exception {

                        //那么就正常执行
                        if (mSession != null) {
                            mSession.setLogin(true);
                        }

                        if (loginBean != null) {

                            //用户的token信息
                            String userToken = loginBean.getUserToken();

                            //社区管家相关的
                            String areaId = loginBean.getAreaId();
                            String customerId = loginBean.getCustomerId();
                            String customerInfoId = loginBean.getCustomerInfoId();

                            String nickName = loginBean.getNickName();

                            String photoUrl = loginBean.getPhotoUrl();
//                            String workJob = loginBean.ge;
                            String phone = loginBean.getPhone();//后台返回的有值
                            String trueName = loginBean.getTrueName();//真实姓名
                            String loginName = loginBean.getLoginName();//登录时候文本框内输入的名字 2021-9-1 09:19:37

                            //有一个communityId
                            String communityId = loginBean.getCommunityId();

                            //用户所在的企业id
                            String companyId = loginBean.getCompanyId();

                            //有一个
                            String communityName = loginBean.getCommunityName();

                            //客户的角色信息，或者说是岗位信息；
                            ArrayList<CustomerActor> customerActors = loginBean.getCustomerActors();

                            //有一个shopinfoId.
                            //String shopInfoId = loginBean.getShopInfoId();
                            //des添加
//                          ArrayList<MineCenterBean> customerCenterPurviewList = loginBean.getCustomerCenterPurviewList();

                            //存入本地，然后供后期使用
                            mSession.setToken(userToken);//userToken又重新存一遍,是否还有必要？
                            mSession.setNickName(nickName);
                            //-------------------------------------
                            //2021-9-1新增的两个，直接可以判定登录人的
                            mSession.setLoginName(loginName);
                            mSession.setTrueName(trueName);
                            //-------------------------------------

                            mSession.setUserPhone(phone);
                            mSession.setPhotoUrl(photoUrl);
//                            mSession.setWorkJob(workJob);

                            mSession.setCustomerId(customerId);//这种和接口相关的顺序放在最后
                            mSession.setCustomerInfoId(customerInfoId);
                            mSession.setAreaId(areaId);
                            mSession.setCompanyId(companyId);

                            //做测试数据,将来去掉--------------------------------------------------------------
                            mSession.setCommunityId(communityId);//第一重要参数
                            //mSession.setShopInfoOrCommunityName(communityName);//项目名称

                            //---------------------------------------------------------------------------------------------------
                            StringBuffer stringBufferTemp = new StringBuffer();
                            if (customerActors != null && !customerActors.isEmpty()) {
                                for (int indexPosition = 0; indexPosition < customerActors.size(); indexPosition++) {
                                    CustomerActor item = customerActors.get(indexPosition);
                                    if (item != null) {
                                        String actorName = item.getActorName();
                                        if (!TextUtils.isEmpty(actorName)) {
                                            stringBufferTemp.append(actorName);
                                            if (indexPosition != customerActors.size() - 1) {
                                                stringBufferTemp.append("；");
                                            }
                                        }
                                    }
                                }
                            }
                            mSession.setWorkJob(stringBufferTemp.toString());//部门，在【我的】顶部展示的
                            //-------------------------------------------------------------------------------------------------------
                            //这个多做一次存储
                            //MMKV.defaultMMKV().encode(ConstantApi.P_COMMUNITYID, communityId);
                            //LogUtils.d(ConstantApi.LOGCAT_NOMAL+MMKV.defaultMMKV().decodeString(ConstantApi.P_COMMUNITYID));

                            //mSession.setShopInfoId(shopInfoId);//第二重要参数

                            //------------------------------------------------------------------------------
                            //sp之中的一份存储完毕，往数据库之中存入一份；
                            LoginInfoDaoManager.getInstance().insertOrReplaceLoginInfo(loginBean);
                            //------------------------------------------------------------------------------
                            //------------------------------------------------------------------------------

                            if (login_index_flag == ExtraValue.RESPONSE_20401) {//跳转到首页并且回到“首页指示器”

                                //这里需要通知首页刷新的
                                //EventBus.getDefault().post(new SingleHomeEvent(ConstantApi.NOTIFYDATASET_CHANGED_HOME));

                                //本地做个记录是 由于退出登录 进来的
                                MMKV.defaultMMKV().encode(ConstantSign.P_REQUEST_20401, true);

                                //-------------------------------------------------------------------------------
                                Bundle bundle = new Bundle();

                                bundle.putInt(ExtraKey.EXTRA_LOGINKEY, ExtraValue.RESPONSE_20401);

                                //2020年3月12日09:45:30 这种因为【退出登录又重新登录】的页面，又要跳转到 首页，然后导致需要重新刷新首页

                                // TODO: 2023-08-04 14:18 测试登录成功仍停留在该页面 ,真实放开；
                                ActivityUtils.startActivity(bundle, HomeMainFragmentActivity.class);

                                //2018年06月15日这种也可能需要重新检测是否是业主，也是需要重新调用接口的
                                //所以这里当去往首页跳转的时候，该用户是已经登录的状态了。
                                //该登录界面到首页之后就不必再回来，故杀死.

                            } else {

                                ActivityUtils.startActivity(HomeMainFragmentActivity.class);

                            }
                            //-----------------------------------------------------------------------------
//                            //登录完毕上传几个重要参数上去，知道谁登录了谁的账号,实践中，有同事相互登录同事账号的现象；
//                            HashMap<String, Object> hashMapParameter = new HashMap<>();
//                            hashMapParameter.put(Parameterkey.communityName, loginBean.getCommunityName());
//                            hashMapParameter.put(Parameterkey.customerId, loginBean.getCommunityId());
//                            hashMapParameter.put(Parameterkey.customerInfoId, loginBean.getCustomerInfoId());
//                            hashMapParameter.put(Parameterkey.trueName, loginBean.getTrueName());
//                            hashMapParameter.put(Parameterkey.loginName, loginBean.getLoginName());
//                            hashMapParameter.put(Parameterkey.phone, loginBean.getPhone());
//                            hashMapParameter.put(Parameterkey.userToken, loginBean.getUserToken());
//                            hashMapParameter.put(Parameterkey.logintimecustom, TimeUtils.getNowString());
//
//                            //2022年11月3日20:12:37 获取用户登录的真实密码
//                            //addLogUpLoadInfo.getHashMapParameter().put("passwortrue", yourPassword);
//
//                            new ApiRequestSubListener<>(ConstantApi.IS_ACTIVITY_ITSELF, LoginActivity.this) {
//                            }.addLogInApiRequestListener(//
//                                    mActivityInstance,//
//                                    addLogUpLoadInfo.getUrlPath(),//
//                                    addLogUpLoadInfo.getRequestMethod(),
//                                    addLogUpLoadInfo.getHashMapParameter(),//
//                                    "login success");//

                            //-----------------------------------------------------------------------------

                            //该界面杀死掉
                            methodBack();

                        } else {

                            ToastUtils.showShort(R.string.user_login_data_abnomal);

                        }

                    }

                    //自定义

                }, new ErrorConsumer() {

                    @Override
                    protected void error(ApiException e) {


                    }
                });
    }

    /**
     * 展示校检信息
     */
    private void method_showAlert(String messageContent) {

        CommUtils.checkDialog(mAlertView);

        //楼栋信息为空提示
        mAlertView = new AlertView(ConstantSign.ALERT_TITLE,//
                messageContent, //
                null,//
                new String[]{ConstantSign.ALERT_SINGLE}, //
                null, //
                LoginCarActivity.this, //
                AlertView.Style.Alert,//
                new OnItemClickListener() {
                    @Override
                    public void onItemClick(Object o, int position) {

                        if (position == 0) {

                            if (mAlertView != null && mAlertView.isShowing()) {
                                mAlertView.dismiss();
                            }

                        }

                    }
                });

        if (mAlertView != null) {
            mAlertView.setCancelable(true);
            mAlertView.show();
        }

    }

    private void methodUpdateVersion() {

        //只放在启动的时候更新吧。
        //如果被设置了true,就是点击了取消或者本次点击下载失败等
//        boolean flag = mSession.isQuitUpdate();
        //LogUtils.d("itchen---LoginActivity---flag=" + flag);
//        if (!flag) {

        if (mCompositeDisposable != null) {

            //延迟N秒执行，因为有可能有权限弹窗。
            mCompositeDisposable.add(Observable.timer(ConstantApi.TIME_DELAY2000, TimeUnit.SECONDS)//
                    //.just(0,1)
                    .subscribeOn(AndroidSchedulers.mainThread())//
                    .observeOn(AndroidSchedulers.mainThread())//
                    .compose(LoginCarActivity.this.bindUntilEvent(ActivityEvent.DESTROY))//
                    .subscribe(new Consumer<Long>() {
                        @Override
                        public void accept(Long aLong) throws Exception {

                            // : 2023-08-14 08:57 暂时不处理，因为测试有弹窗
                            getVersion();

                        }
                    }));

        }
//        }
    }

    private void getVersion() {

        if (mCompositeDisposable != null) {

            //简单写法
            mCompositeDisposable.add(Observable.just(0)//
                    .compose(LoginCarActivity.this.bindUntilEvent(ActivityEvent.DESTROY))//
                    .subscribeOn(AndroidSchedulers.mainThread())//
                    .observeOn(AndroidSchedulers.mainThread()).subscribe(new Consumer<Integer>() {//
                        @Override
                        public void accept(Integer valueInteger) throws Throwable {//

                            if (CommUtils.getServiceVersionCode(Session.get(LoginCarActivity.this)) > AppUtils.getAppVersionCode()) {

                                final File apkFile = new File(PathUtils.getExternalAppCachePath() + File.separator +//
                                        mSession.getDownloadurlCurrent().substring(mSession.getDownloadurlCurrent().lastIndexOf("/") + 1));

                                if (FileUtils.isFileExists(apkFile)) {
                                    if (CommUtils.getUninatllApkInfo(Utils.getApp(), apkFile.getAbsolutePath())) {
                                        AppUtils.installApp(apkFile.getAbsolutePath());
                                    } else {
                                        //如果已存在的安装包不完整那么也直接弹窗提示
                                        showDownLoadDialog(mSession.getDownloadurlCurrent());
                                    }
                                } else {
                                    showDownLoadDialog(mSession.getDownloadurlCurrent());
                                }

                            }
                        }
                    }));

        }
    }

    private void showDownLoadDialog(final String _downLoadUrlCurrent) {

        if (materialDialogHasUpdateData != null && materialDialogHasUpdateData.isShowing()) {
            materialDialogHasUpdateData.dismiss();
        }

        if (ActivityUtils.isActivityAlive(LoginCarActivity.this)) {

            materialDialogHasUpdateData = new MaterialDialog.Builder(LoginCarActivity.this)
                    .title(R.string.updateinfotitle)
                    .titleColor(ContextCompat.getColor(Utils.getApp(), R.color.dark))
                    .content(StringUtils.getString(R.string.updateappinfo))
                    .contentColor(ContextCompat.getColor(Utils.getApp(), R.color.dark))
                    .positiveText(R.string.updateformserver)//右侧下载：从服务器下载
                    .positiveColor(ContextCompat.getColor(Utils.getApp(), R.color.red_normal))
                    .negativeText(R.string.updatebuttoncancel)//左侧取消
                    .negativeColor(ContextCompat.getColor(Utils.getApp(), R.color.colormobutton))
                    .neutralText(R.string.updateforlooker)//中性的-从浏览器下载
                    .neutralColor(ContextCompat.getColor(Utils.getApp(), R.color.colormobutton))//中性的
                    .onPositive(new MaterialDialog.SingleButtonCallback() {//从服务器下载；
                        @Override
                        public void onClick(MaterialDialog dialog, DialogAction which) {

                            if (Build.VERSION.SDK_INT < Build.VERSION_CODES.TIRAMISU) {

                                if (!AndPermission.hasPermissions(mActivityInstance, Permission.READ_EXTERNAL_STORAGE, Permission.WRITE_EXTERNAL_STORAGE)) {

                                    CommUtils.checkMaterialDialog(materialDialog);

                                    materialDialog = CommUtils.authorityRequest(mActivityInstance, ConstantSign.MATERIALDIALOG_AUTHORITY_CONTENT_STORAGE, new AuthorityCallbackListener() {
                                        @Override
                                        public void doSomeThing() {

                                            CommUtils.checkMaterialDialog(materialDialog);

                                            //2018年06月05日发现这里添加SD卡的存储权限内容
                                            AndPermission.with(LoginCarActivity.this)//
                                                    .runtime()//
                                                    .permission(Permission.READ_EXTERNAL_STORAGE,//
                                                            Permission.WRITE_EXTERNAL_STORAGE)//
                                                    .rationale(new RuntimeRationale())//
                                                    .onGranted(new com.yanzhenjie.permission.Action<List<String>>() {//
                                                        @Override
                                                        public void onAction(List<String> permissions) {

                                                            method_inside_download(_downLoadUrlCurrent);

                                                        }
                                                    }).onDenied(new com.yanzhenjie.permission.Action<List<String>>() {
                                                        @Override
                                                        public void onAction(List<String> permissions) {
                                                            //弹出失败弹窗
                                                            if (AndPermission.hasAlwaysDeniedPermission(LoginCarActivity.this, permissions)) {//
                                                                PermissionSetting mSetting = new PermissionSetting(LoginCarActivity.this);
                                                                mSetting.showSetting(ConstantApi.PERMISSION_NORMAL, LoginCarActivity.this, permissions);//
                                                            }
                                                        }
                                                    }).start();

                                        }
                                    });

                                } else {
                                    method_inside_download(_downLoadUrlCurrent);
                                }

                            } else {

                                if (!XXPermissions.isGranted(LoginCarActivity.this, com.hjq.permissions.Permission.MANAGE_EXTERNAL_STORAGE)) {

                                    CommUtils.checkMaterialDialog(materialDialog);

                                    materialDialog = CommUtils.authorityRequest(mActivityInstance, ConstantSign.MATERIALDIALOG_AUTHORITY_CONTENT_STORAGE, new AuthorityCallbackListener() {

                                        @Override
                                        public void doSomeThing() {

                                            CommUtils.checkMaterialDialog(materialDialog);

                                            XXPermissions.with(LoginCarActivity.this)
                                                    // 适配分区存储应该这样写
                                                    //.permission(Permission.Group.STORAGE)
                                                    // 不适配分区存储应该这样写
//                                                        .permission(com.hjq.permissions.Permission.MANAGE_EXTERNAL_STORAGE)//
                                                    .permission(com.hjq.permissions.Permission.MANAGE_EXTERNAL_STORAGE)//
                                                    .interceptor(new PermissionInterceptor())
                                                    .request(new OnPermissionCallback() {

                                                        @Override
                                                        public void onGranted(@NonNull List<String> permissions, boolean allGranted) {

                                                            if (!allGranted) {
                                                                return;
                                                            }

                                                            Toaster.show(String.format(getString(R.string.demo_obtain_permission_success_hint),
                                                                    PermissionNameConvert.getPermissionString(LoginCarActivity.this, permissions)));

                                                            method_inside_download(_downLoadUrlCurrent);

                                                        }
                                                    });

                                        }
                                    });

                                } else {

                                    method_inside_download(_downLoadUrlCurrent);

                                }
                            }

                        }
                    })
                    .onNegative(new MaterialDialog.SingleButtonCallback() {
                        @Override
                        public void onClick(MaterialDialog dialog, DialogAction which) {

                            //取消的
                            dialog.dismiss();

                        }
                    }).onNeutral(new MaterialDialog.SingleButtonCallback() {
                        @Override
                        public void onClick(@NonNull MaterialDialog dialog, @NonNull DialogAction which) {

                            //直接启用浏览器下载
                            CommUtils.method_inside_download(_downLoadUrlCurrent, LoginCarActivity.this);

                            dialog.dismiss();
                        }
                    }).dismissListener(new DialogInterface.OnDismissListener() {
                        @Override
                        public void onDismiss(DialogInterface dialog) {

//                            mSession.setQuitUpdate(true);
                            //LogUtils.d("itchen触发取消视图的事件dismissListener");
                        }
                    }).canceledOnTouchOutside(true).show();//这个可以随时获取就放开点击消失

            //2019/1/27 去掉设置顶部标题
            //materialDialog.getTitleView().setTextSize(13);
            materialDialogHasUpdateData.getTitleView().setTextSize(15);
            materialDialogHasUpdateData.getActionButton(DialogAction.POSITIVE).setTextSize(15);
            //materialDialogUpdate.getActionButton(DialogAction.NEGATIVE).setTextSize(15);

        }
    }

    //直接执行下载
    private void method_inside_download(String _downLoadUrlCurrent) {

        //LogUtils.d("itchen--确定按钮");
//        mSession.setQuitUpdate(true);

        //2019年12月11日 这段代码暂时不用。
//        Intent updateIntent = new Intent();
//        updateIntent.setClass(SettingActivity.this, UpdateService.class);
//        updateIntent.putExtra(Parameterkey.nameapk, AppUtils.getAppName());
//        updateIntent.putExtra(Parameterkey.urlapk, _downLoadUrlCurrent);
//
//        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
//            startForegroundService(updateIntent);
//        } else {
//            startService(updateIntent);
//        }
//
//        //将来如果这一块有问题直接屏蔽即可
//        showProgressDialog();


        //使用浏览器下载 ：
        //弹窗其实是否打开链接
//        final Intent intent = new Intent();
//        intent.setAction(Intent.ACTION_VIEW);
//        intent.setData(Uri.parse(_downLoadUrlCurrent));
//        // 注意此处的判断intent.resolveActivity()可以返回显示该Intent的Activity对应的组件名
//        // 官方解释 : Name of the component implementing an activity that can display the intent
//        if (intent.resolveActivity(SettingActivity.this.getPackageManager()) != null) {
//            //final ComponentName componentName = intent.resolveActivity(getPackageManager());
//            // 打印Log   ComponentName 到底是什么
//            //Log.e(TAG, "componentName = " + componentName.getClassName());
//            mActivityInstance.startActivity(Intent.createChooser(intent, getString(R.string.plesechooseintent)));
//
//        } else {
//            ToastUtils.showShort(R.string.nochooseappdownload);
//        }

        //PathUtils.getExternalAppCachePath() + File.separator + ConstantSign.DOWNAPP + File.separator,//
        //                (down_url.substring(down_url.lastIndexOf("/") + 1)

        //打开下载进度的弹窗内容；
        //将来如果这一块有问题直接屏蔽即可
        showProgressDialog();

        //String filePath = PathUtils.getExternalAppCachePath() + File.separator + ConstantSign.DOWNAPP + File.separator+(_downLoadUrlCurrent.substring(_downLoadUrlCurrent.lastIndexOf("/") + 1));
//        String filePath = PathUtils.getExternalAppFilesPath() + File.separator + (_downLoadUrlCurrent.substring(_downLoadUrlCurrent.lastIndexOf("/") + 1));
        //String filePath = PathUtils.getExternalAppCachePath() + File.separator + (_downLoadUrlCurrent.substring(_downLoadUrlCurrent.lastIndexOf("/") + 1));

//        LogUtils.d(ConstantSign.LOGCAT_NOMAL + "下载存放路径地址-->" + CarApplication.getInstance().getApkDownLoadPath(_downLoadUrlCurrent));
        //itchen-->下载地址-->/data/user/0/com.ygxsk.integrated/cache/ccce9ab2828d449f93b5ce3754a05e71.apk

        //使用第三方下载
        taskDownLoadApkId = Aria.download(this)
                .load(_downLoadUrlCurrent)
                .setFilePath(CarApplication.getInstance().getApkDownLoadPath(_downLoadUrlCurrent)) //设置文件保存的完整路径
                .create();   //启动下载

    }

    private void showProgressDialog() {

        //关闭上一个
        CommUtils.checkMaterialDialog(materialDialogHasUpdateData);
        CommUtils.checkMaterialDialog(materialDialogDownLoadProgress);

        if (ActivityUtils.isActivityAlive(LoginCarActivity.this)) {

            materialDialogDownLoadProgress = new MaterialDialog.Builder(LoginCarActivity.this)
                    .title(AppUtils.getAppName())
                    .content(R.string.downloadingwait)
                    .contentGravity(GravityEnum.CENTER)
                    .progress(false, 100, true)//itchen自己更改 false水平进度条
                    .positiveText(R.string.backgrounddown)//右侧下载
                    .positiveColor(ContextCompat.getColor(Utils.getApp(), R.color.red_normal))
                    .negativeText(R.string.downloadingcancel)//左侧取消
                    .negativeColor(ContextCompat.getColor(Utils.getApp(), R.color.colormobutton))
                    .onPositive(new MaterialDialog.SingleButtonCallback() {
                        @Override
                        public void onClick(MaterialDialog dialog, DialogAction which) {

                            dialog.dismiss();//取消弹窗，取消下载，取消发送进度内容

                        }
                    })
                    .onNegative(new MaterialDialog.SingleButtonCallback() {
                        @Override
                        public void onClick(MaterialDialog dialog, DialogAction which) {

                            //触发取消下载。
                            //杀死服务和服务内发送下载的方法
                            //binderInterface.callCancel();

                            //调用下载器的 取消
                            if (Aria.download(LoginCarActivity.this).load(taskDownLoadApkId).isRunning()) {
                                Aria.download(LoginCarActivity.this).load(taskDownLoadApkId).cancel();
                            }

                        }
                    }).canceledOnTouchOutside(false)//
                    .show();//

            //先创建，然后更新
            //2019/1/27 不修改标题字号,显示为默认的
            materialDialogDownLoadProgress.getTitleView().setTextSize(16);
            //materialDialogProgress.getProgressBar().setAlpha(ContextCompat.getColor(Dutils.getApp(),R.color.colormobutton));
            materialDialogDownLoadProgress.getProgressBar().setAlpha(1);

            materialDialogDownLoadProgress.getActionButton(DialogAction.POSITIVE).setTextSize(15);
            materialDialogDownLoadProgress.getActionButton(DialogAction.NEGATIVE).setTextSize(15);
        }

    }


    //在这里处理任务执行中的状态，如进度进度条的刷新
    @Download.onTaskRunning
    protected void running(DownloadTask task) {

//        if(task.getKey().eques(task.getKey())){
//        ....
//            可以通过url判断是否是指定任务的回调
//        }
        int p = task.getPercent();  //任务进度百分比
//        String speed = task.getConvertSpeed();  //转换单位后的下载速度，单位转换需要在配置文件中打开
//        String speed1 = String.valueOf(task.getSpeed()); //原始byte长度速度
//        LogUtils.d(ConstantSign.LOGCAT_NOMAL+"下载进度是-->"+speed);
        //LogUtils.d(ConstantSign.LOGCAT_NOMAL + "下载进度是-->" + p);

        if (callbackResult != null) {
            callbackResult.OnBackResult(p);
        }

    }

    @Download.onTaskComplete
    void taskComplete(DownloadTask task) {
        //在这里处理任务完成的状态
        //下载完毕
//        LogUtils.d(ConstantSign.LOGCAT_NOMAL + "下载完毕；");

        CommUtils.checkMaterialDialog(materialDialogHasUpdateData);
        if (materialDialogHasUpdateData != null) {
            materialDialogHasUpdateData = null;
        }

        CommUtils.checkMaterialDialog(materialDialogDownLoadProgress);
        if (materialDialogDownLoadProgress != null) {
            materialDialogDownLoadProgress = null;
        }

        //String filePath = PathUtils.getExternalAppCachePath() + File.separator + (_downLoadUrlCurrent.substring(_downLoadUrlCurrent.lastIndexOf("/") + 1));
//        LogUtils.d(ConstantSign.LOGCAT_NOMAL + "下载完毕后的地址-->" + task.getFilePath());
        //itchen-->下载完毕后的地址-->/storage/emulated/0/Android/data/com.ygxsk.integrated/files/ea72151429fb4dc0b802ff026fadb22a.apk
        //itchen-->下载完毕后的地址-->/data/user/0/com.ygxsk.integrated/cache/2970b8290303428eb08f0805be10db3d.apk


        //直接启用安装
        if (!TextUtils.isEmpty(task.getFilePath())) {
            if (CommUtils.getUninatllApkInfo(LoginCarActivity.this, task.getFilePath())) {
                ///data/user/0/com.ygxsk.integrated/cache/2970b8290303428eb08f0805be10db3d.apk
                AppUtils.installApp(task.getFilePath());
            }
        }

    }

    @Download.onTaskCancel
    void taskCancel(DownloadTask task) {

        //LogUtils.d(ConstantSign.LOGCAT_NOMAL+"---->下载取消---");

        //mAdapter.updateState(task.getEntity());
        //判断这个任务在运行的状态中，那么，就直接停止它；
//        if (Aria.download(SettingActivity.this).load(taskDownLoadApkId).isRunning()){
//            Aria.download(SettingActivity.this).load(taskDownLoadApkId).stop();
//        }

        //直接关闭 下载弹窗；
        //立即关闭弹窗的
        CommUtils.checkMaterialDialog(materialDialogHasUpdateData);
        CommUtils.checkMaterialDialog(materialDialogDownLoadProgress);

        ToastUtils.showLong(R.string.downlaodappcancel);

    }

    /**
     * @param e 异常信息
     */
    @Download.onTaskFail
    void taskFail(DownloadTask task, Exception e) {

        //立即关闭弹窗的
        CommUtils.checkMaterialDialog(materialDialogHasUpdateData);
        CommUtils.checkMaterialDialog(materialDialogDownLoadProgress);

        //ALog.d(TAG, ALog.getExceptionString(e));
        //下载任务失败
        //下载失败
        if (!TextUtils.isEmpty(ALog.getExceptionString(e))) {
            ToastUtils.showShort(ALog.getExceptionString(e));
//            LogUtils.d(ConstantSign.LOGCAT_NOMAL + "---->下载报错--->" + ALog.getExceptionString(e));

            //提示下载失败：
            ToastUtils.showShort(ALog.getExceptionString(e));
        }

    }

    @Override
    public boolean onKeyDown(int keyCode, KeyEvent event) {

        if (keyCode == KeyEvent.KEYCODE_BACK && event.getRepeatCount() == 0) {

            //===================================================================================================
            //如果选项卡在第三个并且webview可以回退那么该逻辑失效
            //2019年03月29日 第二模块修改为商品团购
            /*if (mRg_main != null) {

                if (mRg_main.getCheckedRadioButtonId() == R.id.rb_gongxiao) {//如果是当前正处于供销界面

                    if (mSession.getX5WebView() != null) {

                        //在这里强制转换一次减少使用X5的次数。
                        if ((mSession.getX5WebView()).canGoBack()) {
                            //LogUtils.d("itchen--拦截了一次---->" + mSession.getX5WebView().canGoBack());
                            //LogUtils.d("itchen--RxBus即将发送一次家装返回消息");
                            //执行回退web逻辑
                            RxBus.getInstance().post(new RxSupplyMarket(ConstantApi.RXBUS_HOMEBUYBACK));

                            return true;//执行拦截

                        } else {
                            //LogUtils.d("itchen-没有拦截到-" + (mSession.getX5WebView()).canGoBack());
                        }
                    }
                }

            }*/
            //===================================================================================================

            if (!isExit) {

                isExit = true;
                ToastUtils.showShort(getString(R.string.textexit));
                mHandler.sendEmptyMessageDelayed(EXTI_HANDLER, 2000);

            } else {

                if (mSession != null) {
                    //LogUtils.d("itchen---->应用即将 退出");
//                    _sessionErrorActivity.deleteObservers();
//                    _sessionErrorActivity.close();

                    //itchen这个先不清理，最后清理
                    /*if (mRg_main!=null){

                        if (mBaseFragment!=null&&(!mBaseFragment.isEmpty())){
                            mBaseFragment.clear();
                            mBaseFragment = null;
                        }

                        mRg_main.post(new Runnable() {
                            @Override
                            public void run() {
                                mRg_main.clearCheck();
                                mRg_main.removeAllViews();
                                mRg_main=null;
                            }
                        });
                    }*/

                    mSession = null;
                }

                if (ActivityUtils.isActivityAlive(LoginCarActivity.this)) {
                    ActivityUtils.finishActivity(LoginCarActivity.this);
                }

                if (MianTaskManager.getInstance(this) != null) {
                    MianTaskManager.getInstance(this).finishAllActivity();
                }

                ActivityUtils.finishAllActivities();

                AppUtils.exitApp();

            }

            return false;
        }

        return super.onKeyDown(keyCode, event);
    }

    @Override
    protected void onDestroy() {
        super.onDestroy();

        CommUtils.checkMaterialDialog(materialDialogDownLoadProgress);
        CommUtils.checkMaterialDialog(materialDialogHasUpdateData);

        if (!ObjectUtils.isEmpty(mHandler)) {
            mHandler.removeCallbacksAndMessages(null);
            //mHandler= null;
        }

    }

    @Override
    protected void methodBack() {

        //返回按钮的内容
        ActivityUtils.finishActivity(LoginCarActivity.class);

    }
}